home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / mx / effects / Tween.as < prev    next >
Encoding:
Text File  |  2010-05-14  |  9.6 KB  |  351 lines
  1. package mx.effects
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import flash.events.TimerEvent;
  5.    import flash.utils.Timer;
  6.    import flash.utils.getTimer;
  7.    import mx.core.UIComponentGlobals;
  8.    import mx.core.mx_internal;
  9.    import mx.events.TweenEvent;
  10.    
  11.    use namespace mx_internal;
  12.    
  13.    public class Tween extends EventDispatcher
  14.    {
  15.       mx_internal static const VERSION:String = "2.0.1.0";
  16.       
  17.       private static var activeTweens:Array = [];
  18.       
  19.       private static var interval:Number = 10;
  20.       
  21.       private static var timer:Timer = null;
  22.       
  23.       mx_internal static var intervalTime:Number = NaN;
  24.       
  25.       private var started:Boolean = false;
  26.       
  27.       public var duration:Number = 3000;
  28.       
  29.       private var id:int;
  30.       
  31.       private var arrayMode:Boolean;
  32.       
  33.       private var _isPlaying:Boolean = true;
  34.       
  35.       private var startValue:Object;
  36.       
  37.       public var listener:Object;
  38.       
  39.       private var userEquation:Function;
  40.       
  41.       private var previousUpdateTime:Number;
  42.       
  43.       mx_internal var needToLayout:Boolean = false;
  44.       
  45.       private var updateFunction:Function;
  46.       
  47.       private var _doSeek:Boolean = false;
  48.       
  49.       mx_internal var startTime:Number;
  50.       
  51.       private var endFunction:Function;
  52.       
  53.       private var endValue:Object;
  54.       
  55.       private var _doReverse:Boolean = false;
  56.       
  57.       private var _playheadTime:Number = 0;
  58.       
  59.       private var _invertValues:Boolean = false;
  60.       
  61.       private var maxDelay:Number = 87.5;
  62.       
  63.       public function Tween(param1:Object, param2:Object, param3:Object, param4:Number = -1, param5:Number = -1)
  64.       {
  65.          mx_internal::needToLayout = false;
  66.          maxDelay = 87.5;
  67.          _doSeek = false;
  68.          _isPlaying = true;
  69.          _doReverse = false;
  70.          userEquation = defaultEasingFunction;
  71.          started = false;
  72.          duration = 3000;
  73.          _playheadTime = 0;
  74.          _invertValues = false;
  75.          super();
  76.          if(!param1)
  77.          {
  78.             return;
  79.          }
  80.          if(param2 is Array)
  81.          {
  82.             arrayMode = true;
  83.          }
  84.          this.listener = param1;
  85.          this.startValue = param2;
  86.          this.endValue = param3;
  87.          if(!isNaN(param4) && param4 != -1)
  88.          {
  89.             this.duration = param4;
  90.          }
  91.          if(!isNaN(param5) && param5 != -1)
  92.          {
  93.             maxDelay = 1000 / param5;
  94.          }
  95.          if(param4 == 0)
  96.          {
  97.             endTween();
  98.          }
  99.          else
  100.          {
  101.             Tween.addTween(this);
  102.          }
  103.       }
  104.       
  105.       mx_internal static function removeTween(param1:Tween) : void
  106.       {
  107.          removeTweenAt(param1.id);
  108.       }
  109.       
  110.       private static function addTween(param1:Tween) : void
  111.       {
  112.          param1.id = activeTweens.length;
  113.          activeTweens.push(param1);
  114.          if(!timer)
  115.          {
  116.             timer = new Timer(interval);
  117.             timer.addEventListener(TimerEvent.TIMER,timerHandler);
  118.             timer.start();
  119.          }
  120.          else
  121.          {
  122.             timer.start();
  123.          }
  124.          if(isNaN(mx_internal::intervalTime))
  125.          {
  126.             mx_internal::intervalTime = getTimer();
  127.          }
  128.          param1.mx_internal::startTime = param1.previousUpdateTime = mx_internal::intervalTime;
  129.       }
  130.       
  131.       private static function timerHandler(param1:TimerEvent) : void
  132.       {
  133.          var _loc2_:Boolean = false;
  134.          var _loc3_:Number = NaN;
  135.          var _loc4_:int = 0;
  136.          var _loc5_:int = 0;
  137.          var _loc6_:Tween = null;
  138.          _loc2_ = false;
  139.          _loc3_ = mx_internal::intervalTime;
  140.          mx_internal::intervalTime = getTimer();
  141.          _loc5_ = _loc4_ = int(activeTweens.length);
  142.          while(_loc5_ >= 0)
  143.          {
  144.             _loc6_ = Tween(activeTweens[_loc5_]);
  145.             if(_loc6_)
  146.             {
  147.                _loc6_.mx_internal::needToLayout = false;
  148.                _loc6_.mx_internal::doInterval();
  149.                if(_loc6_.mx_internal::needToLayout)
  150.                {
  151.                   _loc2_ = true;
  152.                }
  153.             }
  154.             _loc5_--;
  155.          }
  156.          if(_loc2_)
  157.          {
  158.             UIComponentGlobals.mx_internal::layoutManager.validateNow();
  159.          }
  160.          param1.updateAfterEvent();
  161.       }
  162.       
  163.       private static function removeTweenAt(param1:int) : void
  164.       {
  165.          var _loc2_:int = 0;
  166.          var _loc3_:int = 0;
  167.          var _loc4_:Tween = null;
  168.          if(param1 >= activeTweens.length || param1 < 0)
  169.          {
  170.             return;
  171.          }
  172.          activeTweens.splice(param1,1);
  173.          _loc2_ = int(activeTweens.length);
  174.          _loc3_ = param1;
  175.          while(_loc3_ < _loc2_)
  176.          {
  177.             _loc4_ = Tween(activeTweens[_loc3_]);
  178.             --_loc4_.id;
  179.             _loc3_++;
  180.          }
  181.          if(_loc2_ == 0)
  182.          {
  183.             mx_internal::intervalTime = NaN;
  184.             timer.reset();
  185.          }
  186.       }
  187.       
  188.       public function pause() : void
  189.       {
  190.          _isPlaying = false;
  191.       }
  192.       
  193.       mx_internal function get playheadTime() : Number
  194.       {
  195.          return _playheadTime;
  196.       }
  197.       
  198.       mx_internal function get playReversed() : Boolean
  199.       {
  200.          return _invertValues;
  201.       }
  202.       
  203.       public function resume() : void
  204.       {
  205.          _isPlaying = true;
  206.          mx_internal::startTime = mx_internal::intervalTime - _playheadTime;
  207.          if(_doReverse)
  208.          {
  209.             reverse();
  210.             _doReverse = false;
  211.          }
  212.       }
  213.       
  214.       public function setTweenHandlers(param1:Function, param2:Function) : void
  215.       {
  216.          this.updateFunction = param1;
  217.          this.endFunction = param2;
  218.       }
  219.       
  220.       mx_internal function set playReversed(param1:Boolean) : void
  221.       {
  222.          _invertValues = param1;
  223.       }
  224.       
  225.       public function set easingFunction(param1:Function) : void
  226.       {
  227.          userEquation = param1;
  228.       }
  229.       
  230.       private function defaultEasingFunction(param1:Number, param2:Number, param3:Number, param4:Number) : Number
  231.       {
  232.          return param3 / 2 * (Math.sin(Math.PI * (param1 / param4 - 0.5)) + 1) + param2;
  233.       }
  234.       
  235.       public function endTween() : void
  236.       {
  237.          var _loc1_:TweenEvent = null;
  238.          var _loc2_:Object = null;
  239.          _loc1_ = new TweenEvent(TweenEvent.TWEEN_END);
  240.          _loc2_ = mx_internal::getCurrentValue(duration);
  241.          _loc1_.value = _loc2_;
  242.          dispatchEvent(_loc1_);
  243.          if(endFunction != null)
  244.          {
  245.             endFunction(_loc2_);
  246.          }
  247.          else
  248.          {
  249.             listener.onTweenEnd(_loc2_);
  250.          }
  251.          Tween.removeTweenAt(id);
  252.       }
  253.       
  254.       public function reverse() : void
  255.       {
  256.          if(_isPlaying)
  257.          {
  258.             _doReverse = false;
  259.             seek(duration - _playheadTime);
  260.             _invertValues = !_invertValues;
  261.          }
  262.          else
  263.          {
  264.             _doReverse = !_doReverse;
  265.          }
  266.       }
  267.       
  268.       mx_internal function doInterval() : Boolean
  269.       {
  270.          var _loc1_:Boolean = false;
  271.          var _loc2_:Number = NaN;
  272.          var _loc3_:Object = null;
  273.          var _loc4_:TweenEvent = null;
  274.          var _loc5_:TweenEvent = null;
  275.          _loc1_ = false;
  276.          previousUpdateTime = mx_internal::intervalTime;
  277.          if(_isPlaying || _doSeek)
  278.          {
  279.             _loc2_ = mx_internal::intervalTime - mx_internal::startTime;
  280.             _playheadTime = _loc2_;
  281.             _loc3_ = mx_internal::getCurrentValue(_loc2_);
  282.             if(_loc2_ >= duration && !_doSeek)
  283.             {
  284.                endTween();
  285.                _loc1_ = true;
  286.             }
  287.             else
  288.             {
  289.                if(!started)
  290.                {
  291.                   _loc5_ = new TweenEvent(TweenEvent.TWEEN_START);
  292.                   dispatchEvent(_loc5_);
  293.                   started = true;
  294.                }
  295.                _loc4_ = new TweenEvent(TweenEvent.TWEEN_UPDATE);
  296.                _loc4_.value = _loc3_;
  297.                dispatchEvent(_loc4_);
  298.                if(updateFunction != null)
  299.                {
  300.                   updateFunction(_loc3_);
  301.                }
  302.                else
  303.                {
  304.                   listener.onTweenUpdate(_loc3_);
  305.                }
  306.             }
  307.             _doSeek = false;
  308.          }
  309.          return _loc1_;
  310.       }
  311.       
  312.       public function seek(param1:Number) : void
  313.       {
  314.          var _loc2_:Number = NaN;
  315.          _loc2_ = mx_internal::intervalTime;
  316.          previousUpdateTime = _loc2_;
  317.          mx_internal::startTime = _loc2_ - param1;
  318.          _doSeek = true;
  319.       }
  320.       
  321.       mx_internal function getCurrentValue(param1:Number) : Object
  322.       {
  323.          var _loc2_:Array = null;
  324.          var _loc3_:int = 0;
  325.          var _loc4_:int = 0;
  326.          if(duration == 0)
  327.          {
  328.             return endValue;
  329.          }
  330.          if(_invertValues)
  331.          {
  332.             param1 = duration - param1;
  333.          }
  334.          if(arrayMode)
  335.          {
  336.             _loc2_ = [];
  337.             _loc3_ = int(startValue.length);
  338.             _loc4_ = 0;
  339.             while(_loc4_ < _loc3_)
  340.             {
  341.                _loc2_[_loc4_] = userEquation(param1,startValue[_loc4_],endValue[_loc4_] - startValue[_loc4_],duration);
  342.                _loc4_++;
  343.             }
  344.             return _loc2_;
  345.          }
  346.          return userEquation(param1,startValue,Number(endValue) - Number(startValue),duration);
  347.       }
  348.    }
  349. }
  350.  
  351.